%load_ext autoreload
%autoreload 2


from datetime import datetime
from pathlib import Path

import numpy as np
import pandas as pd
import plotly.express as px
import seaborn as sns
from IPython.display import display, HTML
from pandas_profiling.profile_report import ProfileReport
from sklearn.linear_model import SGDRegressor, Lasso, Ridge, LinearRegression, ElasticNet
from sklearn.metrics import r2_score
from sklearn.model_selection import cross_val_score, train_test_split, cross_validate, RepeatedKFold
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.svm import SVR
import phik
from tqdm import tqdm

from src.data.preprocessing import preprocessing
from src.features.build_features import build_features
from src.jutils.data import DataUtils
from src.jutils.visual import Plot
from src.data.procesamiento_datos import Preprocesamiento, LimpiezaCalidad, ProcesamientoDatos
import joblib

# Funciones utilizadas para realizar un preprocesamiento general.

def validar_duplicados(_df):
    _filas = _df.shape[0]
    _cant_duplicados = _df.duplicated().sum()
    print(f'De {_filas} registros hay {_cant_duplicados} filas duplicadas, representando el {_cant_duplicados/_filas:.2%}')

def eliminar_duplicados(_df):
    # Eliminando duplicados
    _df = _df.drop_duplicates(keep='first')
    _filas = _df.shape[0]
    print(f'Después de la eliminación de duplicados, el conjunto de datos queda con {_filas} filas.')
    return _df

def validar_index_duplicados(_df):
    # Validando duplicados de index
    _son_duplicados = _df['index'].duplicated()
    _cant_duplicados = _son_duplicados.sum()
    _filas = _df.shape[0]
    print(f'De {_filas} registros, hay {_cant_duplicados} registros con index duplicado, que representan el {_cant_duplicados/_filas:.2%}.')
    return _son_duplicados

def convertir_col_date_a_date(_df):
    _df['date'] = pd.to_datetime(_df['date'], errors='coerce')
    return _df

def reemplazar_valores_extremos(_df, _columnas_numericas):
    _df[_columnas_numericas] = _df[_columnas_numericas].where(lambda x: x > -1e+10, other=np.nan).where(
        lambda x: x < 1e+10, other=np.nan)
    return _df

def reemplazar_nulos_por_la_media(_df, _columnas_numericas):
    # Se reemplazan los valores nulos por la media Nota: No se considera que haya data leakage pues los valores
    # reemplazados son entre registros con el mismo index y como al final se va a dejar un dataset con index únicos,
    # no hay riesgo que estén tanto en el set de entrenamiento como en el de test
    for columna_numerica in _columnas_numericas:
        _df[columna_numerica] = _df[columna_numerica].fillna(
            _df.groupby('index')[columna_numerica].transform('median'))
    return _df

def reemplazar_fechas_nulas(_df):
    # Reemplazando fechas nulas por la primera fecha no nula
    _df['date'] = _df['date'].fillna(
        _df.groupby(['index'], sort=False)['date'].apply(lambda x: x.ffill().bfill()))
    return _df

def reemplazar_ceros_por_nulos(_df):
    # Reemplazando ceros por valores nulos
    _df[['sqft_basement', 'yr_renovated']] = _df[['sqft_basement', 'yr_renovated']].replace(0, np.nan)
    return _df

# Funciones utilizadas para procesar únicamente los datos de entrenamiento
def z_score_outliers(_df, _column):
    """
    Returns:
        zscore, outlier
    """
    # Adaptado de https://www.kaggle.com/code/shweta2407/regression-on-housing-data-accuracy-87
    #creating lists to store zscore and outliers 
    zscore = []
    isoutlier =[]
    # for zscore generally taken thresholds are 2.5, 3 or 3.5 hence i took 3
    threshold = 3
    # calculating the mean of the passed column
    mean = np.mean(_df[_column])
    # calculating the standard deviation of the passed column
    std = np.std(_df[_column])
    for i in _df[_column]:
        z = (i-mean)/std
        zscore.append(z)
        #if the zscore is greater than threshold = 3 that means it is an outlier
        isoutlier.append(np.abs(z) > threshold)
    return zscore, isoutlier

# Funciones para realizar el procesamiento de los datos antes de ingresar al modelo
def mediana_recortada_imputacion(_df, _column, _isoutlier):
    mediana_recortada = _df[_column][~_isoutlier].median()
    _df.loc[_isoutlier, _column] = mediana_recortada
    return _df

def calculo_variables_adicionales(_df):
    _df['tiene_sotano'] = (~_df['sqft_basement'].isna()).astype(int)
    _df['fue_renovada'] = (~_df['yr_renovated'].isna()).astype(int)
    _df['yr_date'] = _df['date'].dt.year
    _df['antiguedad_venta'] = _df['yr_date'] - _df['yr_built']
    return _df

def procesamiento_datos_faltantes(_df, _columnas):
    _df = _df.dropna(subset=_columnas)
    return _df

def clasificar_columnas(_df, _clasificacion_columnas):
    _df[_clasificacion_columnas['categorica_ordinal']] = _df[_clasificacion_columnas['categorica_ordinal']].astype(int)
    _df[_clasificacion_columnas['numerica_continua']] = _df[_clasificacion_columnas['numerica_continua']].astype(float)
    _df[_clasificacion_columnas['numerica_discreta']] = np.floor(_df[_clasificacion_columnas['numerica_discreta']])
    return _df
    
def imputacion_de_datos(_df, _columnas):
    _df[_columnas] = _df[_columnas].fillna(0)
    return _df

def profiler_to_file(_profiler, archivo):
    print('Ejecutando profiler')
    _profiler.to_file(du.data_folder_path.parent.joinpath('reports/' + archivo))
    return True

def calcular_descriptivas(_df):
    descriptivas = _df.describe()
    descriptivas.loc['rango'] = descriptivas.loc['max'] - descriptivas.loc['min']
    descriptivas.loc['IQR'] = descriptivas.loc['75%'] - descriptivas.loc['25%']
    descriptivas.loc['coef de var'] = descriptivas.loc['std']/descriptivas.loc['mean']
    descriptivas.loc['skewness'] = du.data.skew(numeric_only=True)
    descriptivas.loc['kurtosis'] = du.data.kurtosis(numeric_only=True)
    return descriptivas

plot = Plot()

du = DataUtils(
    Path(r'..\data').resolve().absolute(),
    "kc_house_dataDS.parquet",
    'price',
    lambda path: pd.read_parquet(path),
    lambda df, path: df.to_parquet(path)
)
du.data = du.load_data(du.interim_path.joinpath(du.input_file_name))

# Convirtiendo la columna date a datetime
du.data = convertir_col_date_a_date(du.data)

# Reemplazando valores extremos, menores a -1e+10 o mayores a 1e+10
columnas_numericas = [columna for columna in du.data.columns if columna != 'date']
du.data = reemplazar_valores_extremos(du.data, columnas_numericas)

# Se reemplazan los valores extremos por la media
# Nota: No se considera que haya data leakage pues los valores reemplazados son entre registros con el mismo index y como 
# al final se va a dejar un dataset con index únicos, no hay riesgo que estén tanto en el set de entrenamiento como en el de
# test
du.data = reemplazar_nulos_por_la_media(du.data, columnas_numericas)

# Reemplazando fechas nulas por la primera fecha no nula
du.data = reemplazar_fechas_nulas(du.data)

# Reemplazando ceros por valores nulos
du.data = reemplazar_ceros_por_nulos(du.data)

du.data = du.data.drop(columns=list(unicos[unicos==1].index))

# Calculando variables adicionales
du.data = calculo_variables_adicionales(du.data)

columnas_a_eliminar_nulos = du.data.drop(columns=['yr_renovated', 'sqft_basement']).columns
du.data = procesamiento_datos_faltantes(du.data, columnas_a_eliminar_nulos)

du.data= clasificar_columnas(du.data, clasificacion_columnas)